package com.changgou.order.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.changgou.order.config.TokenDecode;
import com.changgou.goods.Feign.skuFeign;
import com.changgou.order.dao.OrderItemMapper;
import com.changgou.order.dao.OrderMapper;
import com.changgou.order.pojo.Order;
import com.changgou.order.pojo.OrderItem;
import com.changgou.order.service.OrderService;
import com.changgou.user.feign.UserFeign;
import com.changgou.util.IdWorker;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/****
 * @Author:deng
 * @Description:Order业务层接口实现类
 *****/
@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;
    @Autowired
    private IdWorker idWorker;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private skuFeign skuFeign;
    @Autowired
    private UserFeign userFeign;


    /***
     * 支付失败：逻辑删除订单操作
     * @param orderId
     */
    @Override
    public void deleteOrder(String orderId) {
        //根据订单id查询订单消息
        Order order = orderMapper.selectByPrimaryKey(orderId);
            //订单更新时间
            order.setUpdateTime(new Date());
            //支付状态:支付失败
            order.setPayStatus("2");
            //支付时间
            order.setPayTime(new Date());
            //更新数据库
            orderMapper.updateByPrimaryKeySelective(order);
            //更新redis缓存
            String jsonString = JSONObject.toJSONString(order);
            redisTemplate.boundHashOps("Order").put(orderId,jsonString);



    }

    /***
     * 支付成功后根据订单ID修改订单状态
     * @param orderId
     * @param transactionid 交易流水号
     */
    @Override
    public void updateStatus(String orderId, String transactionid) {
        //根据订单id获取订单信息
        Order order = orderMapper.selectByPrimaryKey(orderId);

            //修改更新时间
            order.setUpdateTime(new Date());
            //付款时间
            order.setPayTime(new Date());
            //交易流水号
            order.setTransactionId(transactionid);
            //支付状态
            order.setPayStatus("1");
            //对数据库中的数据进行更新
            orderMapper.updateByPrimaryKeySelective(order);
            //更新redis缓存
            String jsonString = JSONObject.toJSONString(order);
            redisTemplate.boundHashOps("Order").put(orderId,jsonString);


    }

    /**
     * Order条件+分页查询
     *
     * @param order 查询条件
     * @param page  页码
     * @param size  页大小
     * @return 分页结果
     */
    @Override
    public PageInfo<Order> findPage(Order order, int page, int size) {
        //分页
        PageHelper.startPage(page, size);
        //搜索条件构建
        Example example = createExample(order);
        //执行搜索
        return new PageInfo<Order>(orderMapper.selectByExample(example));
    }

    /**
     * Order分页查询
     *
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Order> findPage(int page, int size) {
        //静态分页
        PageHelper.startPage(page, size);
        //分页查询
        return new PageInfo<Order>(orderMapper.selectAll());
    }

    /**
     * Order条件查询
     *
     * @param order
     * @return
     */
    @Override
    public List<Order> findList(Order order) {
        //构建查询条件
        Example example = createExample(order);
        //根据构建的条件查询数据
        return orderMapper.selectByExample(example);
    }


    /**
     * Order构建查询对象
     *
     * @param order
     * @return
     */
    public Example createExample(Order order) {
        Example example = new Example(Order.class);
        Example.Criteria criteria = example.createCriteria();
        if (order != null) {
            // 订单id
            if (!StringUtils.isEmpty(order.getId())) {
                criteria.andEqualTo("id", order.getId());
            }
            // 数量合计
            if (!StringUtils.isEmpty(order.getTotalNum())) {
                criteria.andEqualTo("totalNum", order.getTotalNum());
            }
            // 金额合计
            if (!StringUtils.isEmpty(order.getTotalMoney())) {
                criteria.andEqualTo("totalMoney", order.getTotalMoney());
            }
            // 优惠金额
            if (!StringUtils.isEmpty(order.getPreMoney())) {
                criteria.andEqualTo("preMoney", order.getPreMoney());
            }
            // 邮费
            if (!StringUtils.isEmpty(order.getPostFee())) {
                criteria.andEqualTo("postFee", order.getPostFee());
            }
            // 实付金额
            if (!StringUtils.isEmpty(order.getPayMoney())) {
                criteria.andEqualTo("payMoney", order.getPayMoney());
            }
            // 支付类型，1、在线支付、0 货到付款
            if (!StringUtils.isEmpty(order.getPayType())) {
                criteria.andEqualTo("payType", order.getPayType());
            }
            // 订单创建时间
            if (!StringUtils.isEmpty(order.getCreateTime())) {
                criteria.andEqualTo("createTime", order.getCreateTime());
            }
            // 订单更新时间
            if (!StringUtils.isEmpty(order.getUpdateTime())) {
                criteria.andEqualTo("updateTime", order.getUpdateTime());
            }
            // 付款时间
            if (!StringUtils.isEmpty(order.getPayTime())) {
                criteria.andEqualTo("payTime", order.getPayTime());
            }
            // 发货时间
            if (!StringUtils.isEmpty(order.getConsignTime())) {
                criteria.andEqualTo("consignTime", order.getConsignTime());
            }
            // 交易完成时间
            if (!StringUtils.isEmpty(order.getEndTime())) {
                criteria.andEqualTo("endTime", order.getEndTime());
            }
            // 交易关闭时间
            if (!StringUtils.isEmpty(order.getCloseTime())) {
                criteria.andEqualTo("closeTime", order.getCloseTime());
            }
            // 物流名称
            if (!StringUtils.isEmpty(order.getShippingName())) {
                criteria.andEqualTo("shippingName", order.getShippingName());
            }
            // 物流单号
            if (!StringUtils.isEmpty(order.getShippingCode())) {
                criteria.andEqualTo("shippingCode", order.getShippingCode());
            }
            // 用户名称
            if (!StringUtils.isEmpty(order.getUsername())) {
                criteria.andLike("username", "%" + order.getUsername() + "%");
            }
            // 买家留言
            if (!StringUtils.isEmpty(order.getBuyerMessage())) {
                criteria.andEqualTo("buyerMessage", order.getBuyerMessage());
            }
            // 是否评价
            if (!StringUtils.isEmpty(order.getBuyerRate())) {
                criteria.andEqualTo("buyerRate", order.getBuyerRate());
            }
            // 收货人
            if (!StringUtils.isEmpty(order.getReceiverContact())) {
                criteria.andEqualTo("receiverContact", order.getReceiverContact());
            }
            // 收货人手机
            if (!StringUtils.isEmpty(order.getReceiverMobile())) {
                criteria.andEqualTo("receiverMobile", order.getReceiverMobile());
            }
            // 收货人地址
            if (!StringUtils.isEmpty(order.getReceiverAddress())) {
                criteria.andEqualTo("receiverAddress", order.getReceiverAddress());
            }
            // 订单来源：1:web，2：app，3：微信公众号，4：微信小程序  5 H5手机页面
            if (!StringUtils.isEmpty(order.getSourceType())) {
                criteria.andEqualTo("sourceType", order.getSourceType());
            }
            // 交易流水号
            if (!StringUtils.isEmpty(order.getTransactionId())) {
                criteria.andEqualTo("transactionId", order.getTransactionId());
            }
            // 订单状态,0:未完成,1:已完成，2：已退货
            if (!StringUtils.isEmpty(order.getOrderStatus())) {
                criteria.andEqualTo("orderStatus", order.getOrderStatus());
            }
            // 支付状态,0:未支付，1：已支付，2：支付失败
            if (!StringUtils.isEmpty(order.getPayStatus())) {
                criteria.andEqualTo("payStatus", order.getPayStatus());
            }
            // 发货状态,0:未发货，1：已发货，2：已收货
            if (!StringUtils.isEmpty(order.getConsignStatus())) {
                criteria.andEqualTo("consignStatus", order.getConsignStatus());
            }
            // 是否删除
            if (!StringUtils.isEmpty(order.getIsDelete())) {
                criteria.andEqualTo("isDelete", order.getIsDelete());
            }
        }
        return example;
    }

    /**
     * 删除
     *
     * @param id
     */
    @Override
    public void delete(String id) {
        orderMapper.deleteByPrimaryKey(id);
    }

    /**
     * 修改Order
     *
     * @param order
     */
    @Override
    public void update(Order order) {
        orderMapper.updateByPrimaryKey(order);
    }

    /**
     * 增加Order//生成订单，
     *
     * @param order
     */
    @GlobalTransactional
    @Override
    public void add(Order order) {
        if (order.getIds() == null) {
            return;
        }
        //存放sku数据
        Map<String, String> skumap = new HashMap<>();
        //存放spu数据
        Map<String, String> spumap = new HashMap<>();
        //解析令牌信息
        Map<String, String> userInfo = TokenDecode.getUserInfo();
        String username = userInfo.get("username");
        //获取用户订单信息
        List<Object> values = redisTemplate.boundHashOps("Cart_" + username).values();
        //对订单生成id
        order.setId("No" + idWorker.nextId());
        //对订单进行数据补充
        Integer num = 0;
        Integer money = 0;
        if (values != null) {
            //对获取到的订单循环
            for (Object value : values) {
                //订单信息中每个商品信息
                OrderItem orderItem = JSONObject.parseObject(value.toString(), OrderItem.class);
                //循环订单中的所有商品id
                for (String id : order.getIds()) {
                    //获取对应的商品信息
                    if (orderItem.getSkuId().equals(id)) {
                        //统计数量
                        num = orderItem.getNum() + num;
                        //统计金额合计
                        money = orderItem.getMoney() + money;
                        //对订单详情表进行补充
                        orderItem.setId("No" + idWorker.nextId()); //生成一个id
                        orderItem.setOrderId(order.getId());// 补充订单id
                        //将订单详情保存到数据库
                        orderItemMapper.insertSelective(orderItem);
                        //记录减少商品库存的信息（商品id，商品购买的数量）
                        skumap.put(orderItem.getSkuId(), orderItem.getNum().toString());
                        //更新spu销量的信息（spuid，spu的数量）
                        spumap.put(orderItem.getSpuId(), orderItem.getNum().toString());
                    }
                }
            }
        }
        order.setTotalNum(num); //数量总计
        order.setTotalMoney(money); //金额总计
        order.setCreateTime(new Date()); //创建时间
        order.setUpdateTime(new Date()); //更新时间
        order.setUsername(username); //用户名字
        order.setSourceType("1"); //订单来源 web
        order.setOrderStatus("0"); //订单状态未完成
        order.setPayStatus("0"); //支付状态未支付
        order.setConsignStatus("0"); //发货状态未发货
        order.setIsDelete("0");//未删除

        //将订单保存到数据库
        orderMapper.insert(order);
        //保存到订单与详情后之后需要从购物车中删除（reids中删除就可以）
        redisTemplate.boundHashOps("Cart_" + username).delete(order.getIds());
        //更新商品库存（）sku
        skuFeign.decrCount(skumap);
        //更新用户积分
        userFeign.addPoints(1000);
        //将订单数据存放在redis，方便查询
        String jsonString = JSONObject.toJSONString(order);
        redisTemplate.boundHashOps("Order").put(order.getId(),jsonString);
    }

    /**
     * 根据ID查询Order
     *
     * @param id
     * @return
     */
    @Override
    public Order findById(String id) {
        return orderMapper.selectByPrimaryKey(id);
    }

    /**
     * 查询Order全部数据
     *
     * @return
     */
    @Override
    public List<Order> findAll() {
        return orderMapper.selectAll();
    }
	
	 /***
     * 查询Order全部数据
     * @return
     */
    @Override
    public HashMap<String, Object>  findAllByUsername(Order order) {


        HashMap<String, Object> map = new HashMap<>();
        Example example = new Example(Order.class);
        Example.Criteria criteria = example.createCriteria();

        if (!StringUtils.isEmpty(order.getUsername())){
            criteria.andEqualTo("username", order.getUsername());
        }
        if (!StringUtils.isEmpty(order.getOrderStatus())){
            criteria.andEqualTo("orderStatus", order.getOrderStatus());
        }
        if (!StringUtils.isEmpty(order.getPayStatus())){
            criteria.andEqualTo("payStatus", order.getPayStatus());
        }
        if (!StringUtils.isEmpty(order.getConsignStatus()
        )){
            criteria.andEqualTo("consignStatus", order.getConsignStatus());
        }
        if (!StringUtils.isEmpty(order.getIsDelete()
        )){
            criteria.andEqualTo("isDelete", order.getIsDelete());
        }
//        if (!StringUtils.isEmpty(order.getCreateTime()
//        )){
//            criteria.andBetween("createTime",order.getCreateTime().getTime()-3*, order.getCreateTime());
//        }

        List<Order> orders = orderMapper.selectByExample(example);
            if (orders != null) {
                for (Order order1 : orders) {
                    OrderItem orderItem = new OrderItem();
                    orderItem.setOrderId(order1.getId());
                    List<OrderItem> select = orderItemMapper.select(orderItem);
                    order1.setOrderItemList(select);

                }}
            map.put("orderlist", orders);
            map.put("count", orders.size());
            return   map;
        }

     /**
     * 同时时间查询
     *
     * @param month
     * @param username
     * @return
     */
    @Override
    public HashMap<String, Object> findByTime(String month, String username) {
        HashMap<String, Object> map = new HashMap<>();
        List<Order> byTime = orderMapper.findByTime(Integer.valueOf(month), username);
        if (byTime.size() > 0 || byTime != null) {
            ArrayList<OrderItem> orderItems = new ArrayList<>();
            for (Order order : byTime) {
                String id = order.getId();
                OrderItem orderItem1 = new OrderItem();
                orderItem1.setOrderId(id);
                List<OrderItem> select = orderItemMapper.select(orderItem1);
                order.setOrderItemList(select);
            }
            map.put("orderlist", byTime);
            map.put("count", byTime.size());
            return map;
        }
        return null;
    }}
